import { handleTree, deepClone, isWeixinBrowser } from '@/utils/common';
import { ref } from 'vue';
import dayjs from 'dayjs';
import relativeTime from 'dayjs/plugin/relativeTime';
import duration from 'dayjs/plugin/duration';
import 'dayjs/locale/zh-cn';
dayjs.locale('zh-cn');
dayjs.extend(relativeTime);
dayjs.extend(duration);
// 转换商品分类
export function formattingCategory(data: any) {

	let yudaoData = deepClone(data)

	let niushopData = yudaoData.map((item: { parentId: any; id: any; name: any; picUrl: any; }) => {
		return {
			pid: item.parentId,
			category_id: item.id,
			category_name: item.name,
			category_full_name: item.name,
			image: item.picUrl
		}

	})

	let category = handleTree(niushopData, 'category_id', 'pid', 'child_list');
	return category
}

export function formatDate(date: Date, format?: string): string {
	// 日期不存在，则返回空
	if (!date) {
		return ''
	}
	// 日期存在，则进行格式化
	return date ? dayjs(date).format(format ?? 'YYYY-MM-DD HH:mm:ss') : ''
}
/**
 * @description 格式化时间
 * @param {String|Number} dateTime 需要格式化的时间戳
 * @param {String} fmt 格式化规则 yyyy:mm:dd|yyyy:mm|yyyy年mm月dd日|yyyy年mm月dd日 hh时MM分等,可自定义组合 默认yyyy-mm-dd
 * @returns {string} 返回格式化后的字符串
 */
export function timeFormat(dateTime = null, formatStr = 'yyyy-mm-dd') {
	let date;
	// 若传入时间为假值，则取当前时间
	if (!dateTime) {
		date = new Date();
	}
	// 若为unix秒时间戳，则转为毫秒时间戳（逻辑有点奇怪，但不敢改，以保证历史兼容）
	else if (/^\d{10}$/.test(dateTime?.toString().trim())) {
		date = new Date(dateTime * 1000);
	}
	// 若用户传入字符串格式时间戳，new Date无法解析，需做兼容
	else if (typeof dateTime === 'string' && /^\d+$/.test(dateTime.trim())) {
		date = new Date(Number(dateTime));
	}
	// 其他都认为符合 RFC 2822 规范
	else {
		// 处理平台性差异，在Safari/Webkit中，new Date仅支持/作为分割符的字符串时间
		date = new Date(typeof dateTime === 'string' ? dateTime.replace(/-/g, '/') : dateTime);
	}

	const timeSource = {
		y: date.getFullYear().toString(), // 年
		m: (date.getMonth() + 1).toString().padStart(2, '0'), // 月
		d: date.getDate().toString().padStart(2, '0'), // 日
		h: date.getHours().toString().padStart(2, '0'), // 时
		M: date.getMinutes().toString().padStart(2, '0'), // 分
		s: date.getSeconds().toString().padStart(2, '0'), // 秒
		// 有其他格式化字符需求可以继续添加，必须转化成字符串
	};

	for (const key in timeSource) {
		const [ret] = new RegExp(`${key}+`).exec(formatStr) || [];
		if (ret) {
			// 年可能只需展示两位
			const beginIndex = key === 'y' && ret.length === 2 ? 2 : 0;
			formatStr = formatStr.replace(ret, timeSource[key].slice(beginIndex));
		}
	}

	return formatStr;
}
export const formatNumberToWan = (num: any) => {
	if (Math.abs(num) >= 10000) {
		return (num / 10000).toFixed(2) + '万';
	}
	return num.toString();
}
export const skuSpecFormat = (properties: any) => {
	let sku_spec_format = ''
	if (properties && properties.length > 0) {
		sku_spec_format = properties.map((value: any) => {
			return value.valueName
		}).toString()
	} else {
		sku_spec_format = ''
	}
	return sku_spec_format

}
/**
 * 处理卡项属性展示
 * @param item  商品对应的sku
 * @param isSowLabel 是否展示标签
 * @param isSowAttrValues  是否展示属性
 * @returns
 */
const cardDate = [{
	value: 0,
	label: '日'
}, {
	value: 1,
	label: '月'
}, {
	value: 2,
	label: '年'
}, {
	value: 3,
	label: '不限'
},]

export const filterCardAttributes = (
	item: any,
	isSowLabel: any = false,
	isSowAttrValues: any = true
) => {
	const usableDurationUnit = cardDate.find((ele) => {
		return ele.value == item.usableDurationUnit
	})?.label

	// 如果是计次卡
	let label = ''
	let attrValues = ''
	if (item.skuType == 20) {
		label = `次数`
		attrValues = `${item.usableTimes}次`
	} else if (item.skuType == 21) {
		label = `时间`
		if (item.usableDurationUnit == 3) {
			attrValues = '不限时'
		} else {
			// 如果是计时卡
			attrValues = `${item.usableDuration}${usableDurationUnit}`
		}
	} else {
		// 如果是计时计次卡
		label = `时间/次数`

		if (item.usableDurationUnit == 3) {
			attrValues = `不限时/${item.usableTimes}次`
		} else {
			attrValues = `${item.usableDuration}${usableDurationUnit}/${item.usableTimes}次`
		}
	}
	return `${isSowLabel ? label : ''} ${isSowAttrValues ? attrValues : ''}`
}
/**
 * 格式化订单状态
 *
 * @param order 订单
 */
export const formatOrderStatus = (order: any) => {
	if (order.status === 0) {
		return '待付款';
	}
	if (order.status === 1) {
		return '到店付';
	}
	if (order.status === 2) {
		return '已支付';
	}
	if (order.status === 3) {
		return '已服务';
	}
	if (order.status === 4) {
		return '待成团';
	}
	if (order.status === 5) {
		return '已退款';
	}
	if (order.status === 9) {
		return '已换购';
	}

	if (order.status === 10) {
		return '待发货';
	}
	if (order.status === 80) {
		return '待核销';
	}
	if (order.status === 20) {
		return '已发货';
	}
	if (order.status === 21) {
		return '退款申请中';
	}
	if (order.status === 23) {
		return '已驳回';
	}

	if (order.status === 30 && !order.commentStatus) {
		return '待评价';
	}
	if (order.status === 30 && order.commentStatus) {
		return '已完成';
	}
	if (order.status === 40) {
		return '已取消';
	}
	if (order.status === 50) {
		return '已撤销';
	}
	if (order.status === 70) {
		return '有欠款';
	}
	if (order.status === 90) {
		return '到店付';
	}
	return '-';
}

/**
 * 格式化订单类型
 */
export const formatOrderType = (order: any) => {

	if (order.type === 0) {
		return '普通订单';
	}
	if (order.type === 1) {
		return '秒杀订单';
	}
	if (order.type === 2) {
		return '砍价订单';
	}
	if (order.type === 3) {
		return '拼团订单';
	}
	if (order.type === 4) {
		return '积分商城';
	}
	if (order.type === 5) {
		return '服务订单';
	}
	if (order.type === 6) {
		return '活动订单';
	}
	if (order.type === 7) {
		return '寄存订单';
	}
	if (order.type === 8) {
		return '提货订单';
	}
	if (order.type === 9) {
		return '售后订单';
	}
	if (order.type === 10) {
		return '还款订单';
	}
	if (order.type === 11) {
		return '提货订单';
	}
	if (order.type === 20) {
		return '超级拼团';
	}
	if (order.type === 21) {
		return '充值订单';
	}

	return '-';
}
/**
 * 格式化订单来源
 */
export const formatOrderSource = (order: any) => {

	if (order.source === 0) {
		return '平台';
	}
	if (order.source === 1) {
		return '服务商';
	}
	if (order.source === 2) {
		return '供应链';
	}
	if (order.source === 3) {
		return '总部';
	}
	if (order.source === 4) {
		return '门店';
	}
	if (order.source === 5) {
		return '商城';
	}
	if (order.source === 6) {
		return '分账';
	}

	return '-';
}
/**
 * 格式化订单状态的描述
 *
 * @param order 订单
 */
export const formatOrderStatusDescription = (order: any) => {
	if (order.status === 0) {
		// return `请在 ${formatDate(order.payExpireTime)} 前完成支付`;
	}
	if (order.status === 10) {
		return '商家未发货，请耐心等待';
	}
	if (order.status === 20) {
		return '商家已发货，请耐心等待';
	}
	if (order.status === 30 && !order.commentStatus) {
		return '已收货，快去评价一下吧';
	}
	if (order.status === 30 && order.commentStatus) {
		return '交易完成，感谢您的支持';
	}
	return '交易关闭';
}
/**
 * 格式化售后状态的描述
 *
 * @param afterSale 售后
 */
export function formatAfterSaleStatusDescription(afterSale: any) {
	if (afterSale.status === 10) {
		return '退款申请待商家处理';
	}
	if (afterSale.status === 20) {
		return '请退货并填写物流信息';
	}
	if (afterSale.status === 30) {
		return '退货退款申请待商家处理';
	}
	if (afterSale.status === 40) {
		return '等待退款';
	}
	if (afterSale.status === 50) {
		return '退款成功';
	}
	if (afterSale.status === 61) {
		return '退款关闭';
	}
	if (afterSale.status === 62) {
		return `商家不同意退款申请，拒绝原因：${afterSale.auditReason}`;
	}
	if (afterSale.status === 63) {
		return `商家拒绝收货，不同意退款，拒绝原因：${afterSale.auditReason}`;
	}
	return '未知状态';
}
/**
 * 格式化售后状态
 *
 * @param afterSale 售后
 */
export function formatAfterSaleStatus(afterSale: { status: number; }) {
	if (afterSale.status === 10) {
		return '申请售后';
	}
	if (afterSale.status === 20) {
		return '商品待退货';
	}
	if (afterSale.status === 30) {
		return '商家待收货';
	}
	if (afterSale.status === 40) {
		return '等待退款';
	}
	if (afterSale.status === 50) {
		return '退款成功';
	}
	if (afterSale.status === 61) {
		return '买家取消';
	}
	if (afterSale.status === 62) {
		return '商家拒绝';
	}
	if (afterSale.status === 63) {
		return '商家拒收货';
	}
	return '未知状态';
}
/**
 * 格式化admin接口订单售后状态
 *
 * @param afterSale 售后
 */
export function formatAdminAfterSaleStatus(status: number) {

	if (status === 10) {
		return '售后中';
	}
	if (status === 20) {
		return '已退款';
	}
	if (status === 0) {
		return '未售后';
	}

	return '-';
}
/**
 * 格式化admin接口订单配送方式
 *
 * @param deliveryType 售后
 */
export function formatAdminDeliveryType(type: number) {

	if (type === 2) {
		return '门店自提';
	}
	if (type === 1) {
		return '物流配送';
	}
	if (type === 0) {
		return '门店下单';
	}

	return '-';
}
/**
 * 格式化SKUTYPE
 *
 * @param skuType 售后
 */
export function formatSkuType(skuType: number) {

	if (skuType === 20) {
		return '计次';
	}
	if (skuType === 21) {
		return '计时';
	}
	if (skuType === 22) {
		return '计时计次';
	}
	if (skuType === 41) {
		return '储值卡';
	}
	if (skuType === 42) {
		return '提货卡';
	}
	if (skuType === 43) {
		return '会员卡';
	}
	return undefined
}
export function formatSpuType(type: number) {

	if (type === 1) {
		return '商品';
	}
	if (type === 2) {
		return '卡项';
	}
	if (type === 3) {
		return '组合商品';
	}
	if (type === 4) {
		return '卡类商品';
	}
	if (type === 5) {
		return '付费会员';
	}
	if (type === 6) {
		return '音视频';
	}
	if (type === 7) {
		return '优惠券';
	}
	return '-';
}
//转化优惠券使用范围
export function formatCouponProductScope(type: number) {

	if (type === 1) {
		return '通用劵';
	}
	if (type === 2) {
		return '商品券';
	}
	if (type === 3) {
		return '分类券';
	}
	if (type === 4) {
		return '品类券';
	}
	if (type === 5) {
		return '品牌券';
	}

	return '-';
}
/**
* 将分转成元
*
* @param price 分，例如说 100 分
* @returns {string} 元，例如说 1.00 元
*/

export function fen2yuan(price: number) {
	return (price / 100.0).toFixed(2);
}
/**
* 将元
*
* @param price 分，例如说 100 分
* @returns {string} 元，例如说 1.00 元
*/

export function yuan2fen(num: number) {
	if (typeof num === 'undefined') return 0
	const parsedNumber = typeof num === 'string' ? parseFloat(num) : num
	// TODO 分转元后还有小数则四舍五入
	return Math.round(parsedNumber * 100)
}
/**
 * 倒计时
 * @param toTime   截止时间
 * @param fromTime 起始时间，默认当前时间
 * @return {{s: string, ms: number, h: string, m: string}} 持续时间
 */
export function useDurationTime(toTime: number, fromTime = '') {
	toTime = getDayjsTime(toTime);
	if (fromTime === '') {
		fromTime = dayjs();
	}
	let duration = ref(toTime - fromTime);
	if (duration.value > 0) {
		setTimeout(() => {
			if (duration.value > 0) {
				duration.value -= 1000;
			}
		}, 1000);
	}

	let durationTime = dayjs.duration(duration.value);
	return {
		h: (durationTime.months() * 30 * 24 + durationTime.days() * 24 + durationTime.hours())
			.toString()
			.padStart(2, '0'),
		m: durationTime.minutes().toString().padStart(2, '0'),
		s: durationTime.seconds().toString().padStart(2, '0'),
		ms: durationTime.$ms,
	};
}

/**
 * 转换为 Dayjs
 * @param {any} time 时间
 * @return {dayjs.Dayjs}
 */
function getDayjsTime(time: string | string[]) {
	time = time.toString();
	if (time.indexOf('-') > 0) {
		// 'date'
		return dayjs(time);
	}
	if (time.length > 10) {
		// 'timestamp'
		return dayjs(parseInt(time));
	}
	if (time.length === 10) {
		// 'unixTime'
		return dayjs.unix(parseInt(time));
	}
}

/** 当前平台 */


export function getPlatform() {
	const device = uni.getSystemInfoSync();
	const os = device.platform;
	let platform = {
		name: '',
		provider: '',
		terminal: '0',
		platform: '',
		isWechatInstalled: true
	}
	// #ifdef H5
	if (isWeixinBrowser()) {
		platform.name = 'WechatOfficialAccount';
		platform.provider = 'wechat';
		platform.platform = 'officialAccount';
	} else {
		platform.name = 'H5';
		platform.platform = 'h5';
	}
	// #endif

	// #ifdef APP-PLUS
	platform.name = 'andriod';
	platform.platform = 'openPlatform';
	// 检查微信客户端是否安装，否则AppleStore会因此拒绝上架
	if (os === 'ios') {
		platform.name = 'ios';
		platform.isWechatInstalled = plus.ios.import('WXApi').isWXAppInstalled();

	}
	// #endif
	// #ifdef MP-WEIXIN
	platform.name = 'wxapp';
	platform.platform = 'miniProgram';
	platform.provider = 'wechat';
	// #endif
	return platform
}
export function nickNameFormat(name: string) {
	if (name) {
		const str = name.substring(0, 1) + '**'
		return str;

	} else {
		return '**';
	}
}
/**
 * 获取指定日期的开始时间、截止时间
 * @param beginDate 开始日期
 * @param endDate 截止日期
 */
export function getDateRange(
	beginDate: dayjs.ConfigType,
	endDate: dayjs.ConfigType
): [string, string] {
	return [
		dayjs(beginDate).startOf('d').format('YYYY-MM-DD HH:mm:ss'),
		dayjs(endDate).endOf('d').format('YYYY-MM-DD HH:mm:ss')
	]
}
/**
 * 获取本月的第一天的0点00分 到目前日期的 23点59分
 */
export function getNowMonthDate() {
	const date = new Date()
	date.setDate(1) // 设置为当前月的第一天
	return getDateRange(date, new Date())
}

